home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
JCSM Shareware Collection 1993 November
/
JCSM Shareware Collection - 1993-11.iso
/
cl720
/
sst115j.lzh
/
SSTEDT.C
< prev
next >
Wrap
C/C++ Source or Header
|
1992-07-18
|
21KB
|
803 lines
/* ------------------------------------------------------------------------ */
/* sstedit.c */
/* high-level editor routines */
/* */
/* CopyRight (C) 1991,1992 Steven Lutrov. All rights reserved. */
/* ------------------------------------------------------------------------ */
#include <stdio.h>
#include <ctype.h>
#include <mem.h>
#include <conio.h>
#include <alloc.h>
#include "sstvid.h"
#include "sstwin.h"
#include "sstkey.h"
/* ------------------------------------------------------------------------ */
/* macros */
/* ------------------------------------------------------------------------ */
#define NEXTTAB (TAB-(x%TAB))
#define LASTTAB ((wwd/TAB)*TAB)
#define PREVTAB (((x-1)%TAB)+1)
#define curr(x,y) (bfptr+(y)*wwd+(x))
#define lineno(y) ((int)(bfptr-topptr)/wwd+(y))
/* ------------------------------------------------------------------------ */
/* local variables */
/* ------------------------------------------------------------------------ */
extern int VSG;
int last_x, last_y;
static int wht;
static int wwd;
static int wsz;
static char *topptr;
static char *bfptr;
static char *lstptr;
static int lines;
static char *endptr;
static int blkbeg;
static int blkend;
static int inserting;
static WINDOW *wnd;
static int do_display_text = 1;
/* ------------------------------------------------------------------------ */
/* local function prototypes */
/* ------------------------------------------------------------------------ */
void erase_buffer (int *x, int *y);
int lastword (int x, int y);
void last_char (int *x, int *y);
void test_para (int x, int y);
int trailing_spaces (int y);
int first_wordlen (int y);
void paraform (int x, int y);
int blankline (int line);
void delete_word (int x, int y);
void delete_line (int y);
void delete_block (void);
void copy_block (int y);
void move_block (int y);
void mvblock (int y, int moving);
void findlast (void);
void find_end (int *x, int *y);
void carrtn (int *x, int *y, int insert);
void backspace (int *x, int *y);
void fore_word (int *x, int *y, char *bf);
int spaceup (int *x, int *y, char **bf);
void back_word (int *x, int *y, char *bf);
int spacedn (int *x, int *y, char **bf);
void forward (int *x, int *y);
int downward (int *y);
void upward (int *y);
void display_text (void);
void disp_line (int y);
void insert_line (void);
/* ------------------------------------------------------------------------ */
/* Process text entry for a window. */
/* ------------------------------------------------------------------------ */
void Eopen(WINDOW *wnd1, char *bf, int bsize)
{
char *b, *buff;
int depart = FALSE, i, c;
int x, y, svx, svlw, tx, tabctr = 0;
wnd = wnd1;
wht = HEIGHT-2;
wwd = WIDTH-2;
wsz = wwd * wht;
topptr = bfptr = bf;
lines = bsize / wwd;
endptr = bf + wwd * lines;
blkbeg = 0;
blkend = 0;
inserting = FALSE;
x = 0;
y = 0;
display_text();
/* --------- read in text from the keyboard ---------- */
findlast();
while (TRUE) {
last_x = COL + 1 + x;
last_y = ROW + 1 + y;
vsetcur(last_x, last_y);
buff = curr(x, y);
if (tabctr) {
--tabctr;
c = ' ';
}
else {
c = kgetch();
/* Wemsgclear(); */
}
switch (c) {
case '\r': carrtn(&x, &y, inserting);
break;
case DOWN: downward(&y);
break;
case PGUP: y = 0;
for (i = 0; i < wht; i++)
upward(&y);
break;
case PGDN: y = HEIGHT - 2;
for (i = 0; i < wht; i++)
downward(&y);
y = 0;
break;
case '\t': if (x + NEXTTAB < wwd) {
if (inserting)
tabctr = NEXTTAB;
else
x += NEXTTAB;
}
else
carrtn(&x, &y, inserting);
break;
case SHIFT_TAB:
if (x < TAB) {
upward(&y);
x = LASTTAB;
}
else
x -= PREVTAB;
break;
case CTRL_RIGHT:
fore_word(&x, &y, buff);
break;
case CTRL_LEFT:
back_word(&x, &y, buff);
break;
case CTRL_PGUP:
y = wht - 1;
break;
case CTRL_PGDN:
y = 0;
break;
case CTRL_HOME:
x = y = 0;
bfptr = topptr;
display_text();
break;
case HOME: x = 0;
break;
case CTRL_END:
find_end(&x, &y);
display_text();
break;
case END: last_char(&x, &y);
break;
case UP: upward(&y);
break;
case F2:
case ESC: depart = TRUE;
break;
case '\b':
case LEFT: if (!(x || y))
break;
backspace(&x, &y);
if (x == wwd - 1)
last_char(&x, &y);
if (c == LEFT)
break;
buff = curr(x, y);
case DEL: movmem(buff+1, buff, wwd-1-x);
*(buff+wwd-1-x) = ' ';
disp_line(y);
test_para(x+1, y);
break;
case CTRL_Y: delete_line(y);
break;
case CTRL_D:delete_word(x, y);
test_para(x, y);
break;
case INS: inserting ^= TRUE;
insert_line();
break;
case F3: erase_buffer(&x, &y);
break;
case F4: paraform(0, y);
break;
case F7: blkbeg = lineno(y) + 1;
if (blkbeg > blkend)
blkend = lines;
display_text();
break;
case F8: blkend = lineno(y) + 1;
if (blkend < blkbeg)
blkbeg = 1;
display_text();
break;
case ALT_F8: move_block(y);
break;
case ALT_F7: copy_block(y);
break;
case F9: delete_block();
break;
case F10: blkbeg = blkend = 0;
display_text();
break;
case RIGHT: forward(&x, &y);
break;
default: if (!isprint(c))
break;
if (curr(x, y) == endptr-1 ||
(lineno(y)+1 >= lines && inserting
&& *curr(wwd-2, y) != ' ')) {
/* Wemsg(" End of Buffer "); */
break;
}
if (inserting) {
buff = curr(x, y);
movmem(buff, buff + 1, wwd-1-x);
}
buff = curr(x, y);
if (buff < endptr) {
if (buff >= lstptr)
lstptr = buff + 1;
*buff = c;
disp_line(y);
}
buff = curr(wwd-1, y);
if (endptr && *buff != ' ') {
for (b = buff+1; b < endptr; b++)
if (*b==' ' && *(b + 1)==' ')
break;
movmem(buff+1, buff+2, b-buff-1);
*(buff+1) = ' ';
svx = x;
svlw = lastword(x, y);
x = wwd-1;
if (*(buff-1) != ' ')
back_word(&x, &y, buff);
tx = x;
carrtn(&x, &y, TRUE);
if (svlw)
x = svx-tx;
else {
x = svx;
--y;
}
}
forward(&x, &y);
break;
}
if (depart)
break;
}
inserting = FALSE;
insert_line();
}
/* ------------------------------------------------------------------------ */
/* erase the buffer */
/* ------------------------------------------------------------------------ */
static void erase_buffer(int *x, int *y)
{
int c = 0;
WINDOW *sur;
sur = Westablish(28, 11, 4, 24);
Wsetcolour(sur, WIN_ALL, RED, YELLOW, BRIGHT);
Wshow(sur);
Wprintf(sur, " Erase text window\n Are you sure? (y/n)");
while (c != 'y' && c != 'n') {
c = kgetch();
c = tolower(c);
if (c == 'y') {
lstptr = bfptr = topptr;
*x = *y = 0;
setmem(bfptr, lines * wwd, ' ');
blkbeg = blkend = 0;
display_text();
}
}
Wdelete(sur);
}
/* ------------------------------------------------------------------------ */
/* see if a word is the last word on the line */
/* ------------------------------------------------------------------------ */
static int lastword(int x, int y)
{
char *bf = curr(x, y);
while (x++ < wwd-1)
if (*bf++ == ' ')
return 0;
return 1;
}
/* ------------------------------------------------------------------------ */
/* go to last displayable character on the line */
/* ------------------------------------------------------------------------ */
static void last_char(int *x, int *y)
{
char *bf;
*x = wwd-1;
bf = curr(0, *y);
while (*x && *(bf + *x) == ' ')
--(*x);
if (*x && *x < wwd - 1)
(*x)++;
}
/* ------------------------------------------------------------------------ */
/* test to see if paragraph should be reformed */
/* ------------------------------------------------------------------------ */
static void test_para(int x, int y)
{
int ts, fw;
int far *c;
c = kstate();
if (! (*c & K_SCROLLLOCKON) && y < lines) {
ts = trailing_spaces(y);
fw = first_wordlen(y+1);
if (fw && ts > fw)
paraform(x, y);
}
}
/* ------------------------------------------------------------------------ */
/* count the trailing spaces on a line */
/* ------------------------------------------------------------------------ */
static int trailing_spaces(int y)
{
int x = wwd-1, ct = 0;
char *bf = curr(0, y);
while (x >= 0) {
if (*(bf + x) != ' ')
break;
--x;
ct++;
}
return ct;
}
/* ------------------------------------------------------------------------ */
/* count the length of the first word on a line */
/* ------------------------------------------------------------------------ */
static int first_wordlen(int y)
{
int ct = 0, x = 0;
char *bf = curr(0, y);
while (x < wwd-1 && *(bf+x) == ' ')
x++;
while (x+ct < wwd-1 && *(bf+x+ct) != ' ')
ct++;
return ct;
}
/* ------------------------------------------------------------------------ */
/* form a paragraph */
/* ------------------------------------------------------------------------ */
static void paraform(int x, int y)
{
char *cp1, *cp2, *cpend, *svcp;
int x1;
if (blankline(lineno(y)+1))
return;
if (!blkbeg) {
blkbeg = blkend = lineno(y)+1;
blkend++;
while (blkend < lines) {
if (blankline(blkend))
break;
blkend++;
}
--blkend;
}
if (lineno(y) != blkbeg-1)
x = 0;
x1 = x;
cp1 = cp2 = topptr + (blkbeg - 1) * wwd + x;
cpend = topptr + blkend * wwd;
while (cp2 < cpend) {
while (*cp2 == ' ' && cp2 < cpend)
cp2++;
if (cp2 == cpend)
break;
/* at a word */
while (*cp2 != ' ' && cp2 < cpend) {
if (x1 >= wwd - 1) {
/* wrap the word */
svcp = cp1 + (wwd - x1);
while (*--cp1 != ' ') {
*cp1 = ' ';
--cp2;
}
x1 = 0;
blkbeg++;
cp1 = svcp;
}
*cp1++ = *cp2++;
x1++;
}
if (cp2 < cpend) {
*cp1++ = ' ';
x1++;
}
}
while (cp1 < cpend)
*cp1++ = ' ';
blkbeg++;
if (blkbeg <= blkend)
delete_block();
blkbeg = blkend = 0;
display_text();
findlast();
}
/* ------------------------------------------------------------------------ */
/* test for a blank line */
/* ------------------------------------------------------------------------ */
static int blankline(int line)
{
char *cp;
int x;
cp = topptr + (line-1) * wwd;
for (x = 0; x < wwd; x++)
if (*(cp + x) != ' ')
break;
return (x == wwd);
}
/* ------------------------------------------------------------------------ */
/* delete a word */
/* ------------------------------------------------------------------------ */
static void delete_word(int x, int y)
{
int wct = 0;
char *cp1, *cp2;
cp1 = cp2 = curr(x, y);
if (*cp2 == ' ')
while (*cp2 == ' ' && x + wct < wwd) {
wct++;
cp2++;
}
else {
while (*cp2 != ' ' && x + wct < wwd) {
wct++;
cp2++;
}
while (*cp2 == ' ' && x + wct < wwd) {
wct++;
cp2++;
}
}
movmem(cp2, cp1, wwd - x - wct);
setmem(cp1 + wwd - x - wct, wct, ' ');
display_text();
findlast();
}
/* ------------------------------------------------------------------------ */
/* delete a line */
/* ------------------------------------------------------------------------ */
static void delete_line(int y)
{
char *cp1, *cp2;
int len;
cp1 = bfptr + y * wwd;
cp2 = cp1 + wwd;
if (cp1 < lstptr) {
len = endptr - cp2;
movmem(cp2, cp1, len);
lstptr -= wwd;
setmem(endptr - wwd, wwd, ' ');
display_text();
}
}
/* ------------------------------------------------------------------------ */
/* delete a block */
/* ------------------------------------------------------------------------ */
static void delete_block()
{
char *cp1, *cp2;
int len;
if (!blkbeg || !blkend) {
putchar(7);
return;
}
cp1 = topptr + blkend * wwd;
cp2 = topptr + (blkbeg - 1) * wwd;
len = endptr - cp1;
movmem(cp1, cp2, len);
setmem(cp2 + len, endptr - (cp2 + len), ' ');
blkbeg = blkend = 0;
lstptr -= (cp1 - cp2);
display_text();
}
/* ------------------------------------------------------------------------ */
/* move and copy text blocks */
/* ------------------------------------------------------------------------ */
static void mvblock(int y, int moving)
{
char *cp1, *cp2, *hd;
int len;
if (!blkbeg || !blkend) {
vbeep(ERROR);
return;
}
if (lineno(y) >= blkbeg-1 && lineno(y) <= blkend-1) {
/* Wemsg("Can't move/copy a block into itself"); */
return;
}
len = (blkend - blkbeg + 1) * wwd;
if ((hd = malloc(len)) == 0)
return;
cp1 = topptr + (blkbeg-1) * wwd;
movmem(cp1, hd, len);
cp2 = topptr + lineno(y) * wwd;
if (moving) {
if (lineno(y) > blkbeg-1)
cp2 -= len;
do_display_text = 0;
delete_block();
do_display_text = 1;
}
if (cp2+len <= endptr) {
movmem(cp2, cp2 + len, endptr - cp2 - len);
movmem(hd, cp2, len);
}
free(hd);
blkbeg = blkend = 0;
display_text();
}
/* ------------------------------------------------------------------------ */
/* copy a block */
/* ------------------------------------------------------------------------ */
static void copy_block(int y)
{
mvblock(y, FALSE);
findlast();
}
/* ------------------------------------------------------------------------ */
/* move a block */
/* ------------------------------------------------------------------------ */
static void move_block(int y)
{
mvblock(y, TRUE);
}
/* ------------------------------------------------------------------------ */
/* find the last character in the buffer */
/* ------------------------------------------------------------------------ */
static void findlast()
{
register char *lp = endptr - 1;
register char *tp = topptr;
while (lp > tp && (*lp == ' ' || *lp == '\0')) {
if (*lp == '\0')
*lp = ' ';
--lp;
}
if (*lp != ' ')
lp++;
lstptr = lp;
}
/* ------------------------------------------------------------------------ */
/* go to the end of the data in the buffer */
/* ------------------------------------------------------------------------ */
static void find_end(int *x, int *y)
{
int ct;
bfptr = lstptr;
ct = (lstptr - topptr) % wsz;
bfptr -= ct;
if (bfptr + wsz > endptr)
bfptr = endptr - wsz;
*y = (ct / wwd);
*x = 0;
downward(y);
}
/* ------------------------------------------------------------------------ */
/* carriage return */
/* ------------------------------------------------------------------------ */
static void carrtn(int *x, int *y, int insert)
{
int insct;
char *cp, *nl;
int ctl = 2;
cp = curr(*x, *y);
nl = cp + ((cp - topptr) % wwd);
if (lineno(*y) + 2 < lines)
if (insert && nl < endptr) {
insct = wwd - *x;
while (ctl--) {
if (endptr > cp + insct) {
movmem(cp, cp+insct, endptr-insct-cp);
setmem(cp, insct, ' ');
}
else if (ctl == 1)
setmem(cp, endptr - cp, ' ');
cp += insct * 2;
insct = *x;
}
}
*x = 0;
downward(y);
if (insert) {
test_para(*x, *y);
display_text();
}
if (lineno(*y) + 2 < lines)
if (insert)
if ((lstptr + wwd) <= endptr)
if (lstptr > curr(*x, *y))
lstptr += wwd;
}
/* ------------------------------------------------------------------------ */
/* move the buffer offset back one position */
/* ------------------------------------------------------------------------ */
static void backspace(int *x, int *y)
{
if (*x == 0) {
if (*y)
*x = wwd - 1;
upward(y);
}
else
--(*x);
}
/* ------------------------------------------------------------------------ */
/* move the buffer offset forward one word */
/* ------------------------------------------------------------------------ */
static void fore_word(int *x, int *y, char *bf)
{
while (*bf != ' ') {
if (spaceup(x, y, &bf) == 0)
return;
if (*x == 0)
break;
}
while (*bf == ' ')
if (spaceup(x, y, &bf) == 0)
return;
}
/* ------------------------------------------------------------------------ */
static int spaceup(int *x, int *y, char **bf)
{
if (*bf == lstptr)
return 0;
(*bf)++;
forward(x, y);
return 1;
}
/* ------------------------------------------------------------------------ */
/* move the buffer offset backward one word */
/* ------------------------------------------------------------------------ */
static void back_word(int *x, int *y, char *bf)
{
spacedn(x, y, &bf);
while (*bf == ' ')
if (spacedn(x, y, &bf) == 0)
return;
while (*bf != ' ') {
if (*x == 0)
return;
if (spacedn(x, y, &bf) == 0)
return;
}
spaceup(x, y, &bf);
}
/* ------------------------------------------------------------------------ */
static int spacedn(int *x, int *y, char **bf)
{
if (*bf == topptr)
return 0;
--(*bf);
backspace(x, y);
return 1;
}
/* ------------------------------------------------------------------------ */
/* move the buffer offset forward one position */
/* ------------------------------------------------------------------------ */
static void forward(int *x, int *y)
{
int ww = wwd;
(*x)++;
if (*x == ww) {
downward(y);
*x = 0;
}
}
/* ------------------------------------------------------------------------ */
/* move the buffer offset down one position */
/* ------------------------------------------------------------------------ */
static int downward(int *y)
{
if (*y < wht - 1) {
(*y)++;
return 1;
}
else if ((bfptr + wsz) < endptr) {
bfptr += wwd;
scroll(wnd, UP);
disp_line(wht-1);
return 1;
}
return 0;
}
/* ------------------------------------------------------------------------ */
/* move the buffer offset up one position */
/* ------------------------------------------------------------------------ */
static void upward(int *y)
{
if (*y)
--(*y);
else if ((topptr + wwd) <= bfptr) {
bfptr -= wwd;
scroll(wnd, DOWN);
disp_line(0);
}
}
/* ------------------------------------------------------------------------ */
/* display all the lines in a window */
/* ------------------------------------------------------------------------ */
static void display_text()
{
int y = 0;
if (do_display_text)
while (y < wht)
disp_line(y++);
}
/* ------------------------------------------------------------------------ */
/* Display a line */
/* ------------------------------------------------------------------------ */
static void disp_line(int y)
{
int x = 0, atr = WFACE;
if (blkbeg || blkend)
if (lineno(y) >= blkbeg-1)
if (lineno(y) <= blkend-1)
atr = WACCENT;
while (x < wwd) {
displ(wnd, x+1, y+1, *(bfptr+y * wwd+x), atr);
x++;
}
}
/* ------------------------------------------------------------------------ */
/* set insert/exchange cursor shape */
/* ------------------------------------------------------------------------ */
static void insert_line()
{
vsetcurtype(inserting ? 0x0106 : 0x0607);
}